package com.dkd.day20250712;

import java.util.LinkedList;
import java.util.Scanner;

public class Main11Copy {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            list.add(sc.nextInt());
        }

        System.out.println(solve(list, n));
    }

    public static int solve(LinkedList<Integer> list, int n) {
        // 倒序排序
        list.sort((a, b) -> b - a);
        int sum = 0;
        for (int num : list) {
            sum += num;
        }

        // 从最多队员（m = n）开始递减检查
        for (int m = n; m >= 1; m--) {
            if (sum % m != 0) continue;  // 如果不能整除，跳过
            int target = sum / m;
            if (target < list.getLast()) continue;  // 如果 target 比最小得分还小，跳过

            // 检查是否可以分成 m 组，每组和为 target
            if (solve2(list, m, sum, target)) {
                return target;  // 返回每组得分
            }
        }

        return sum;  // 默认返回 sum（理论上不会执行到这里）
    }

    public static boolean solve2(LinkedList<Integer> list, int m, int sum, int target) {
        if (target > list.getFirst()) return false;  // 如果 target 比最大得分还大，不可能

        int[] bucket = new int[m];
        return solve3(list, 0, target, bucket);
    }

    public static boolean solve3(LinkedList<Integer> list, int index, int target, int[] bucket) {
        if (index == list.size()) return true;  // 所有数字已分配

        int select = list.get(index);  // 当前数字

        // 尝试放入每个桶
        for (int i = 0; i < bucket.length; i++) {
            if (bucket[i] + select > target) continue;  // 如果超过 target，跳过

            // 剪枝：如果当前桶和前一个桶的值相同，跳过（避免重复计算）
            if (i > 0 && bucket[i] == bucket[i - 1]) continue;

            bucket[i] += select;  // 放入当前桶
            if (solve3(list, index + 1, target, bucket)) return true;  // 递归检查
            bucket[i] -= select;  // 撤销选择（回溯）

            // 剪枝：如果当前桶是空的，且放入 select 后失败，那么其他桶也会失败
            if (bucket[i] == 0) break;
        }

        return false;  // 无法分配
    }
}
